home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / FSM.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  31.8 KB  |  884 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT FSM;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __FSM__}
  27. {$SETC __FSM__ := 1}
  28.  
  29. {$I+}
  30. {$SETC FSMIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __FILES__}
  35. {$I Files.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    MixedMode.p                                                    }
  40. {    OSUtils.p                                                    }
  41. {        Memory.p                                                }
  42.  
  43. {$PUSH}
  44. {$ALIGN MAC68K}
  45. {$LibExport+}
  46.  
  47. CONST
  48. {    The new volume mount flags }
  49.     volMountInteractBit            = 15;                            { Input to VolumeMount: If set, it's OK for the file system }
  50.     volMountInteractMask        = $8000;                        { to perform user interaction to mount the volume }
  51.     volMountChangedBit            = 14;                            { Output from VoumeMount: If set, the volume was mounted, but }
  52.     volMountChangedMask            = $4000;                        { the volume mounting information record needs to be updated. }
  53.     volMountFSReservedMask        = $00ff;                        { bits 0-7 are defined by each file system for its own use }
  54.     volMountSysReservedMask        = $ff00;                        { bits 8-15 are reserved for Apple system use }
  55.  
  56. {
  57.  * The new volume mount info record
  58.  }
  59.  
  60. TYPE
  61.     VolumeMountInfoHeader = RECORD
  62.         length:                    INTEGER;                                { length of location data (including self) }
  63.         media:                    VolumeType;                                { type of media (must be registered with Apple) }
  64.         flags:                    INTEGER;                                { volume mount flags. Variable length data follows }
  65.     END;
  66.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  67.  
  68.  
  69. CONST
  70.     gestaltFSMVersion            = 'fsm ';
  71.  
  72.     
  73. TYPE
  74.     VCBPtr = ^VCB;
  75.  
  76. {
  77.  * Miscellaneous file system values not in Files.h
  78.  }
  79.  
  80. CONST
  81.     fsUsrCNID                    = 16;                            { First assignable directory or file number }
  82. {    File system trap word attribute bits }
  83.     kHFSBit                        = 9;                            { HFS call: bit 9 }
  84.     kHFSMask                    = $0200;
  85.     kAsyncBit                    = 10;                            { Asynchronous call: bit 10 }
  86.     kAsyncMask                    = $0400;
  87.  
  88. {
  89.  * HFSCIProc selectCode values
  90.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  91.  * may be set in these selectCode values.
  92.  }
  93.     kFSMOpen                    = $A000;
  94.     kFSMClose                    = $A001;
  95.     kFSMRead                    = $A002;
  96.     kFSMWrite                    = $A003;
  97.     kFSMGetVolInfo                = $A007;
  98.     kFSMCreate                    = $A008;
  99.     kFSMDelete                    = $A009;
  100.     kFSMOpenRF                    = $A00A;
  101.     kFSMRename                    = $A00B;
  102.     kFSMGetFileInfo                = $A00C;
  103.     kFSMSetFileInfo                = $A00D;
  104.     kFSMUnmountVol                = $A00E;
  105.     kFSMMountVol                = $A00F;
  106.     kFSMAllocate                = $A010;
  107.     kFSMGetEOF                    = $A011;
  108.     kFSMSetEOF                    = $A012;
  109.     kFSMFlushVol                = $A013;
  110.     kFSMGetVol                    = $A014;
  111.     kFSMSetVol                    = $A015;
  112.     kFSMEject                    = $A017;
  113.     kFSMGetFPos                    = $A018;
  114.     kFSMOffline                    = $A035;
  115.     kFSMSetFilLock                = $A041;
  116.     kFSMRstFilLock                = $A042;
  117.     kFSMSetFilType                = $A043;
  118.     kFSMSetFPos                    = $A044;
  119.     kFSMFlushFile                = $A045;
  120. {    The File System HFSDispatch selectCodes }
  121.     kFSMOpenWD                    = $0001;
  122.     kFSMCloseWD                    = $0002;
  123.     kFSMCatMove                    = $0005;
  124.     kFSMDirCreate                = $0006;
  125.     kFSMGetWDInfo                = $0007;
  126.     kFSMGetFCBInfo                = $0008;
  127.     kFSMGetCatInfo                = $0009;
  128.     kFSMSetCatInfo                = $000A;
  129.     kFSMSetVolInfo                = $000B;
  130.     kFSMLockRng                    = $0010;
  131.     kFSMUnlockRng                = $0011;
  132.     kFSMCreateFileIDRef            = $0014;
  133.     kFSMDeleteFileIDRef            = $0015;
  134.     kFSMResolveFileIDRef        = $0016;
  135.     kFSMExchangeFiles            = $0017;
  136.     kFSMCatSearch                = $0018;
  137.     kFSMOpenDF                    = $001A;
  138.     kFSMMakeFSSpec                = $001B;
  139. {    The Desktop Manager HFSDispatch selectCodes }
  140.     kFSMDTGetPath                = $0020;
  141.     kFSMDTCloseDown                = $0021;
  142.     kFSMDTAddIcon                = $0022;
  143.     kFSMDTGetIcon                = $0023;
  144.     kFSMDTGetIconInfo            = $0024;
  145.     kFSMDTAddAPPL                = $0025;
  146.     kFSMDTRemoveAPPL            = $0026;
  147.     kFSMDTGetAPPL                = $0027;
  148.     kFSMDTSetComment            = $0028;
  149.     kFSMDTRemoveComment            = $0029;
  150.     kFSMDTGetComment            = $002A;
  151.     kFSMDTFlush                    = $002B;
  152.     kFSMDTReset                    = $002C;
  153.     kFSMDTGetInfo                = $002D;
  154.     kFSMDTOpenInform            = $002E;
  155.     kFSMDTDelete                = $002F;
  156. {    The AppleShare HFSDispatch selectCodes }
  157.     kFSMGetVolParms                = $0030;
  158.     kFSMGetLogInInfo            = $0031;
  159.     kFSMGetDirAccess            = $0032;
  160.     kFSMSetDirAccess            = $0033;
  161.     kFSMMapID                    = $0034;
  162.     kFSMMapName                    = $0035;
  163.     kFSMCopyFile                = $0036;
  164.     kFSMMoveRename                = $0037;
  165.     kFSMOpenDeny                = $0038;
  166.     kFSMOpenRFDeny                = $0039;
  167.     kFSMGetXCatInfo                = $003A;
  168.     kFSMGetVolMountInfoSize        = $003F;
  169.     kFSMGetVolMountInfo            = $0040;
  170.     kFSMVolumeMount                = $0041;
  171.     kFSMShare                    = $0042;
  172.     kFSMUnShare                    = $0043;
  173.     kFSMGetUGEntry                = $0044;
  174.     kFSMGetForeignPrivs            = $0060;
  175.     kFSMSetForeignPrivs            = $0061;
  176.  
  177. {
  178.  * UTDetermineVol status values
  179.  }
  180.     dtmvError                    = 0;                            { param error }
  181.     dtmvFullPathame                = 1;                            { determined by full pathname }
  182.     dtmvVRefNum                    = 2;                            { determined by volume refNum }
  183.     dtmvWDRefNum                = 3;                            { determined by working directory refNum }
  184.     dtmvDriveNum                = 4;                            { determined by drive number }
  185.     dtmvDefault                    = 5;                            { determined by default volume }
  186.  
  187. {
  188.  * UTGetBlock options
  189.  }
  190.     gbDefault                    = 0;                            { default value - read if not found }
  191. {    bits and masks }
  192.     gbReadBit                    = 0;                            { read block from disk (forced read) }
  193.     gbReadMask                    = $0001;
  194.     gbExistBit                    = 1;                            { get existing cache block }
  195.     gbExistMask                    = $0002;
  196.     gbNoReadBit                    = 2;                            { don't read block from disk if not found in cache }
  197.     gbNoReadMask                = $0004;
  198.     gbReleaseBit                = 3;                            { release block immediately after GetBlock }
  199.     gbReleaseMask                = $0008;
  200.  
  201. {
  202.  * UTReleaseBlock options
  203.  }
  204.     rbDefault                    = 0;                            { default value - just mark the buffer not in-use }
  205. {    bits and masks }
  206.     rbWriteBit                    = 0;                            { force write buffer to disk }
  207.     rbWriteMask                    = $0001;
  208.     rbTrashBit                    = 1;                            { trash buffer contents after release }
  209.     rbTrashMask                    = $0002;
  210.     rbDirtyBit                    = 2;                            { mark buffer dirty }
  211.     rbDirtyMask                    = $0004;
  212.     rbFreeBit                    = 3;                            { free the buffer (save in the hash) }
  213. {
  214.  *    rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache;
  215.  *    on >= System 7.0, rbfreeMask overrides rbTrash
  216.  }
  217.     rbFreeMask                    = $000A;
  218.  
  219. {
  220.  * UTFlushCache options
  221.  }
  222.     fcDefault                    = 0;                            { default value - just flush any dirty buffers }
  223. {    bits and masks }
  224.     fcTrashBit                    = 1;                            { trash buffers after flushing }
  225.     fcTrashMask                    = $0002;
  226.     fcFreeBit                    = 3;                            { free buffers after flushing }
  227.     fcFreeMask                    = $0008;                        { fcFreeMask works as fcTrash on < System 7.0 RamCache }
  228.  
  229. {
  230.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  231.  }
  232.     noCacheBit                    = 5;                            { don't cache this please }
  233.     noCacheMask                    = $0020;
  234.     rdVerifyBit                    = 6;                            { read verify }
  235.     rdVerifyMask                = $0040;
  236.  
  237. {
  238.  * Cache routine internal error codes
  239.  }
  240.     chNoBuf                        = 1;                            { no free cache buffers (all in use) }
  241.     chInUse                        = 2;                            { requested block in use }
  242.     chnotfound                    = 3;                            { requested block not found }
  243.     chNotInUse                    = 4;                            { block being released was not in use }
  244.  
  245. {
  246.  * FCBRec.fcbFlags bits
  247.  }
  248.     fcbWriteBit                    = 0;                            { Data can be written to this file }
  249.     fcbWriteMask                = $01;
  250.     fcbResourceBit                = 1;                            { This file is a resource fork }
  251.     fcbResourceMask                = $02;
  252.     fcbWriteLockedBit            = 2;                            { File has a locked byte range }
  253.     fcbWriteLockedMask            = $04;
  254.     fcbSharedWriteBit            = 4;                            { File is open for shared write access }
  255.     fcbSharedWriteMask            = $10;
  256.     fcbFileLockedBit            = 5;                            { File is locked (write-protected) }
  257.     fcbFileLockedMask            = $20;
  258.     fcbOwnClumpBit                = 6;                            { File has clump size specified in FCB }
  259.     fcbOwnClumpMask                = $40;
  260.     fcbModifiedBit                = 7;                            { File has changed since it was last flushed }
  261.     fcbModifiedMask                = $80;
  262.  
  263. {
  264.  * ExtFileProc options
  265.  }
  266.     extendFileAllBit            = 0;                            { allocate all requested bytes or none }
  267.     extendFileAllMask            = $0001;
  268.     extendFileContigBit            = 1;                            { force contiguous allocation }
  269.     extendFileContigMask        = $0002;
  270.  
  271. {
  272.  *    HFS Component Interface constants
  273.  }
  274. {
  275.  * compInterfMask bits specific to HFS component
  276.  }
  277.     hfsCIDoesHFSBit                = 23;                            { set if file system supports HFS calls }
  278.     hfsCIDoesHFSMask            = $00800000;
  279.     hfsCIDoesAppleShareBit        = 22;                            { set if AppleShare calls supported }
  280.     hfsCIDoesAppleShareMask        = $00400000;
  281.     hfsCIDoesDeskTopBit            = 21;                            { set if Desktop Database calls supported }
  282.     hfsCIDoesDeskTopMask        = $00200000;
  283.     hfsCIDoesDynamicLoadBit        = 20;                            { set if dynamically loading code resource }
  284.     hfsCIDoesDynamicLoadMask    = $00100000;                    {        supported }
  285.     hfsCIResourceLoadedBit        = 19;                            { set if code resource already loaded }
  286.     hfsCIResourceLoadedMask        = $00080000;
  287.     hfsCIHasHLL2PProcBit        = 18;                            { set if FFS' log2PhyProc and Extendfile proc }
  288.     hfsCIHasHLL2PProcMask        = $00040000;                    { is written in a high level language. (i.e., uses Pascal calling convention) }
  289.  
  290. {
  291.  *    Disk Initialization Component Interface constants
  292.  }
  293. {
  294.  * compInterfMask bits specific to Disk Initialization component
  295.  }
  296.     diCIHasExtFormatParamsBit    = 18;                            { set if file system needs extended format }
  297.     diCIHasExtFormatParamsMask    = $00040000;                    {        parameters }
  298.     diCIHasMultiVolTypesBit        = 17;                            { set if file system supports more than one }
  299.     diCIHasMultiVolTypesMask    = $00020000;                    {        volume type }
  300.     diCIDoesSparingBit            = 16;                            { set if file system supports disk sparing }
  301.     diCIDoesSparingMask            = $00010000;
  302.     diCILiveBit                    = 0;                            { set if file system is candidate for current }
  303.     diCILiveMask                = $00000001;                    {        formatting operation (set by PACK2) }
  304.  
  305. {
  306.  * Disk Initialization Component Function selectors
  307.  }
  308.     diCILoad                    = 1;                            { Make initialization code memory resident }
  309.     diCIUnload                    = 2;                            { Make initialization code purgeable }
  310.     diCIEvaluateSizeChoices        = 3;                            { Evaluate size choices }
  311.     diCIExtendedZero            = 4;                            { Write an empty volume directory }
  312.     diCIValidateVolName            = 5;                            { Validate volume name }
  313.     diCIGetVolTypeInfo            = 6;                            { get volume type info }
  314.     diCIGetFormatString            = 7;                            { get dialog format string }
  315.     diCIGetExtFormatParams        = 8;                            { get extended format parameters }
  316.     diCIGetDefectList            = 9;                            { return the defect list for the indicated disk - reserved for future use }
  317.  
  318. {
  319.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  320.  }
  321.     diCIFmtListMax                = 8;                            { maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries }
  322. {    bits in FormatListRec.formatFlags: }
  323.     diCIFmtFlagsValidBit        = 7;                            { set if sec, side, tracks valid }
  324.     diCIFmtFlagsValidMask        = $80;
  325.     diCIFmtFlagsCurrentBit        = 6;                            { set if current disk has this fmt }
  326.     diCIFmtFlagsCurrentMask        = $40;
  327. {    bits in FormatListRec.sizeListFlags: }
  328.     diCISizeListOKBit            = 15;                            { set if this disk size usable }
  329.     diCISizeListOKMask            = $8000;
  330.  
  331. {
  332.  * DICIGetFormatStringRec.stringKind format strings
  333.  }
  334.     diCIAlternateFormatStr        = 1;                            { get alternate format  string (Balloon Help) }
  335.     diCISizePresentationStr        = 2;                            { get size presentation string (for dialog) }
  336.  
  337. {
  338.  * Error codes returned by Disk Sparing
  339.  }
  340.     diCIUserCancelErr            = 1;                            { user cancelled the disk init }
  341.     diCICriticalSectorBadErr    = 20;                            { critical sectors are bad (hopeless)    }
  342.     diCISparingFailedErr        = 21;                            { disk cannot be spared }
  343.     diCITooManyBadSectorsErr    = 22;                            { too many bad sectors }
  344.     diCIUnknownVolTypeErr        = 23;                            { the volume type passed in diCIExtendedZero paramBlock is not supported }
  345.     diCIVolSizeMismatchErr        = 24;                            { specified volume size doesn’t match with formatted disk size }
  346.     diCIUnknownDICallErr        = 25;                            { bogus DI function call selector }
  347.     diCINoSparingErr            = 26;                            { disk is bad but the target FS doesn't do disk sparing }
  348.     diCINoExtendInfoErr            = 27;                            { missing file system specific extra parameter in diCIExtendedZero call }
  349.     diCINoMessageTextErr        = 28;                            { missing message text in DIReformat call }
  350.  
  351. {
  352.  *    File System Manager constants
  353.  }
  354. {
  355.  * Miscellaneous constants used by FSM
  356.  }
  357.     fsdVersion1                    = 1;                            { current version of FSD record }
  358.     fsmIgnoreFSID                = $fffe;                        { this FSID should be ignored by the driver }
  359.     fsmGenericFSID                = $ffff;                        { unknown foreign file system ID }
  360.  
  361. {
  362.  * compInterfMask bits common to all FSM components
  363.  }
  364.     fsmComponentEnableBit        = 31;                            { set if FSM component interface is enabled }
  365.     fsmComponentEnableMask        = $80000000;
  366.     fsmComponentBusyBit            = 30;                            { set if FSM component interface is busy }
  367.     fsmComponentBusyMask        = $40000000;
  368.  
  369. {
  370.  * Selectors for GetFSInfo
  371.  }
  372.     fsmGetFSInfoByIndex            = -1;                            { get fs info by index }
  373.     fsmGetFSInfoByFSID            = 0;                            { get fs info by FSID }
  374.     fsmGetFSInfoByRefNum        = 1;                            { get fs info by file/vol refnum }
  375.  
  376. {
  377.  * InformFSM messages
  378.  }
  379.     fsmNopMessage                = 0;                            { nop }
  380.     fsmDrvQElChangedMessage        = 1;                            { DQE has changed }
  381.     fsmGetFSIconMessage            = 2;                            { Get FFS's disk icon }
  382.  
  383. {
  384.  * Messages passed to the fileSystemCommProc
  385.  }
  386.     ffsNopMessage                = 0;                            { nop, should always return noErr }
  387.     ffsGetIconMessage            = 1;                            { return disk icon and mask }
  388.     ffsIDDiskMessage            = 2;                            { identify the about-to-be-mounted volume }
  389.     ffsLoadMessage                = 3;                            { load in the FFS }
  390.     ffsUnloadMessage            = 4;                            { unload the FFS }
  391.     ffsIDVolMountMessage        = 5;                            { identify a VolMountInfo record }
  392.     ffsInformMessage            = 6;                            { FFS defined message }
  393.     ffsGetIconInfoMessage        = 7;
  394.  
  395. {
  396.  * Error codes from FSM functions
  397.  }
  398.     fsmFFSNotFoundErr            = -431;                            { Foreign File system does not exist - new Pack2 could return this error too }
  399.     fsmBusyFFSErr                = -432;                            { File system is busy, cannot be removed }
  400.     fsmBadFFSNameErr            = -433;                            { Name length not 1 <= length <= 31 }
  401.     fsmBadFSDLenErr                = -434;                            { FSD size incompatible with current FSM vers }
  402.     fsmDuplicateFSIDErr            = -435;                            { FSID already exists on InstallFS }
  403.     fsmBadFSDVersionErr            = -436;                            { FSM version incompatible with FSD }
  404.     fsmNoAlternateStackErr        = -437;                            { no alternate stack for HFS CI }
  405.     fsmUnknownFSMMessageErr        = -438;                            { unknown message passed to FSM }
  406.  
  407. {
  408.  *    HFS Utility routine records
  409.  }
  410. {
  411.  * record used by UTGetPathComponentName
  412.  }
  413.  
  414. TYPE
  415.     ParsePathRec = RECORD
  416.         namePtr:                StringPtr;                                { pathname to parse }
  417.         startOffset:            INTEGER;                                { where to start parsing }
  418.         componentLength:        INTEGER;                                { the length of the pathname component parsed }
  419.         moreName:                SignedByte;                                { non-zero if there are more components after this one }
  420.         foundDelimiter:            SignedByte;                                { non-zero if parsing stopped because a colon (:) delimiter was found }
  421.     END;
  422.     ParsePathRecPtr = ^ParsePathRec;
  423.  
  424.     WDCBRec = RECORD
  425.         wdVCBPtr:                VCBPtr;                                    { Pointer to VCB of this working directory }
  426.         wdDirID:                LONGINT;                                { Directory ID number of this working directory }
  427.         wdCatHint:                LONGINT;                                { Hint for finding this working directory }
  428.         wdProcID:                LONGINT;                                { Process that created this working directory }
  429.     END;
  430.     WDCBRecPtr = ^WDCBRec;
  431.  
  432.     FCBRec = RECORD
  433.         fcbFlNm:                LONGINT;                                { FCB file number. Non-zero marks FCB used }
  434.         fcbFlags:                SignedByte;                                { FCB flags }
  435.         fcbTypByt:                SignedByte;                                { File type byte }
  436.         fcbSBlk:                INTEGER;                                { File start block (in alloc size blks) }
  437.         fcbEOF:                    LONGINT;                                { Logical length or EOF in bytes }
  438.         fcbPLen:                LONGINT;                                { Physical file length in bytes }
  439.         fcbCrPs:                LONGINT;                                { Current position within file }
  440.         fcbVPtr:                VCBPtr;                                    { Pointer to the corresponding VCB }
  441.         fcbBfAdr:                Ptr;                                    { File's buffer address }
  442.         fcbFlPos:                INTEGER;                                { Directory block this file is in }
  443.         { FCB Extensions for HFS }
  444.         fcbClmpSize:            LONGINT;                                { Number of bytes per clump }
  445.         fcbBTCBPtr:                Ptr;                                    { Pointer to B*-Tree control block for file }
  446.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                { First 3 file extents }
  447.         fcbFType:                OSType;                                    { File's 4 Finder Type bytes }
  448.         fcbCatPos:                LONGINT;                                { Catalog hint for use on Close }
  449.         fcbDirID:                LONGINT;                                { Parent Directory ID }
  450.         fcbCName:                Str31;                                    { CName of open file }
  451.     END;
  452.     FCBRecPtr = ^FCBRec;
  453.  
  454. {
  455.  *    HFS Component Interface records
  456.  }
  457.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  458.     Lg2PhysUPP = UniversalProcPtr;
  459.  
  460. CONST
  461.     uppLg2PhysProcInfo = $003FEFE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  462.  
  463. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  464.     {$IFC NOT GENERATINGCFM }
  465.     INLINE $2E9F;
  466.     {$ENDC}
  467.  
  468. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  469.     {$IFC NOT GENERATINGCFM}
  470.     INLINE $205F, $4E90;
  471.     {$ENDC}
  472. TYPE
  473.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  474.     HFSCIUPP = UniversalProcPtr;
  475.  
  476. CONST
  477.     uppHFSCIProcInfo = $0000BEE0; { FUNCTION (4 byte param, 2 byte param, 4 byte param, 4 byte param, 2 byte param): 2 byte result; }
  478.  
  479. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  480.     {$IFC NOT GENERATINGCFM }
  481.     INLINE $2E9F;
  482.     {$ENDC}
  483.  
  484. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  485.     {$IFC NOT GENERATINGCFM}
  486.     INLINE $205F, $4E90;
  487.     {$ENDC}
  488.  
  489. TYPE
  490.     HFSCIRec = RECORD
  491.         compInterfMask:            LONGINT;                                { component flags }
  492.         compInterfProc:            HFSCIUPP;                                { pointer to file system call processing code }
  493.         log2PhyProc:            Lg2PhysUPP;                                { pointer to Lg2PhysProc() code }
  494.         stackTop:                Ptr;                                    { file system stack top }
  495.         stackSize:                LONGINT;                                { file system stack size }
  496.         stackPtr:                Ptr;                                    { current file system stack pointer }
  497.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  498.         idSector:                LONGINT;                                { Sector you need to ID a local volume. For networked volumes, this must be -1 }
  499.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  500.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  501.     END;
  502.     HFSCIRecPtr = ^HFSCIRec;
  503.  
  504. {
  505.  *    Disk Initialization Component Interface records
  506.  }
  507.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  508.     DICIUPP = UniversalProcPtr;
  509.  
  510. CONST
  511.     uppDICIProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  512.  
  513. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  514.     {$IFC NOT GENERATINGCFM }
  515.     INLINE $2E9F;
  516.     {$ENDC}
  517.  
  518. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  519.     {$IFC NOT GENERATINGCFM}
  520.     INLINE $205F, $4E90;
  521.     {$ENDC}
  522.  
  523. TYPE
  524.     DICIRec = RECORD
  525.         compInterfMask:            LONGINT;                                { component flags }
  526.         compInterfProc:            DICIUPP;                                { pointer to call processing code }
  527.         maxVolNameLength:        INTEGER;                                { maximum length of your volume name }
  528.         blockSize:                INTEGER;                                { your file system's block size }
  529.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  530.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  531.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  532.     END;
  533.     DICIRecPtr = ^DICIRec;
  534.  
  535. {
  536.  * FormatListRec as returned by the .Sony disk driver's
  537.  * Return Format List status call (csCode = 6).
  538.  * If the status call to get this list for a drive is not
  539.  * implemented by the driver, then a list with one entry
  540.  * is contructed from the drive queue element for the drive.
  541.  }
  542.     FormatListRec = RECORD
  543.         volSize:                LONGINT;                                { disk capacity in SECTORs }
  544.         formatFlags:            SignedByte;                                { flags }
  545.         sectorsPerTrack:        SignedByte;                                { sectors per track side }
  546.         tracks:                    INTEGER;                                { number of tracks }
  547.     END;
  548.     FormatListRecPtr = ^FormatListRec;
  549.  
  550. {
  551.  * SizeListRec built from FormatListRecs as described above.
  552.  }
  553.     SizeListRec = RECORD
  554.         sizeListFlags:            INTEGER;                                { flags as set by external file system }
  555.         sizeEntry:                FormatListRec;                            { disk driver format list record }
  556.     END;
  557.     SizeListRecPtr = ^SizeListRec;
  558.  
  559. {
  560.  * paramBlock for the diCIEvaluateSize call
  561.  }
  562.     DICIEvaluateSizeRec = RECORD
  563.         defaultSizeIndex:        INTEGER;                                { default size for this FS }
  564.         numSizeEntries:            INTEGER;                                { number of size entries }
  565.         driveNumber:            INTEGER;                                { drive number }
  566.         sizeListPtr:            SizeListRecPtr;                            { ptr to size entry table }
  567.         sectorSize:                INTEGER;                                { bytes per sector }
  568.     END;
  569.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  570.  
  571. {
  572.  * paramBlock for the diCIExtendedZero call
  573.  }
  574.     DICIExtendedZeroRec = RECORD
  575.         driveNumber:            INTEGER;                                { drive number }
  576.         volNamePtr:                StringPtr;                                { ptr to volume name string }
  577.         fsid:                    INTEGER;                                { file system ID }
  578.         volTypeSelector:        INTEGER;                                { volume type selector, if supports more than 1 type }
  579.         numDefectBlocks:        INTEGER;                                { number of bad logical blocks }
  580.         defectListSize:            INTEGER;                                { size of the defect list buffer in bytes }
  581.         defectListPtr:            Ptr;                                    { pointer to defect list buffer }
  582.         volSize:                LONGINT;                                { size of volume in SECTORs }
  583.         sectorSize:                INTEGER;                                { bytes per sector }
  584.         extendedInfoPtr:        Ptr;                                    { ptr to extended info }
  585.     END;
  586.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  587.  
  588. {
  589.  * paramBlock for the diCIValidateVolName call
  590.  }
  591.     DICIValidateVolNameRec = RECORD
  592.         theChar:                CHAR;                                    { the character to validate }
  593.         hasMessageBuffer:        BOOLEAN;                                { false if no message }
  594.         charOffset:                INTEGER;                                { position of the current character (first char = 1) }
  595.         messageBufferPtr:        StringPtr;                                { pointer to message buffer or nil }
  596.         charByteType:            INTEGER;                                { theChar's byte type (smSingleByte, smFirstByte, or smLastByte) }
  597.     END;
  598.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  599.  
  600. {
  601.  * paramBlock for the diCIGetVolTypeInfo call
  602.  }
  603.     DICIGetVolTypeInfoRec = RECORD
  604.         volSize:                LONGINT;                                { size of volume in SECTORs }
  605.         sectorSize:                INTEGER;                                { bytes per sector }
  606.         numVolTypes:            INTEGER;                                { number of volume types supported }
  607.         volTypesBuffer:            ARRAY [0..3] OF Str32;                    { 4 string buffers }
  608.     END;
  609.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  610.  
  611. {
  612.  * paramBlock for the diCIGetFormatString call
  613.  }
  614.     DICIGetFormatStringRec = RECORD
  615.         volSize:                LONGINT;                                { volume size in SECTORs }
  616.         sectorSize:                INTEGER;                                { sector size }
  617.         volTypeSelector:        INTEGER;                                { volume type selector }
  618.         stringKind:                INTEGER;                                { sub-function = type of string }
  619.         stringBuffer:            Str255;                                    { string buffer }
  620.     END;
  621.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  622.  
  623. {
  624.  * paramBlock for the diCIGetExtendedFormatParams call
  625.  }
  626.     DICIGetExtendedFormatRec = RECORD
  627.         driveNumber:            INTEGER;                                { drive number }
  628.         volTypeSelector:        INTEGER;                                { volume type selector or 0 }
  629.         volSize:                LONGINT;                                { size of volume in SECTORs }
  630.         sectorSize:                INTEGER;                                { bytes per sector }
  631.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to the foreign file system's FSSpec }
  632.         extendedInfoPtr:        Ptr;                                    { pointer to extended parameter structure }
  633.     END;
  634.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  635.  
  636. {
  637.  *    File System Manager records
  638.  }
  639.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  640.     FSDCommUPP = UniversalProcPtr;
  641.  
  642. CONST
  643.     uppFSDCommProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  644.  
  645. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  646.     {$IFC NOT GENERATINGCFM }
  647.     INLINE $2E9F;
  648.     {$ENDC}
  649.  
  650. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  651.     {$IFC NOT GENERATINGCFM}
  652.     INLINE $205F, $4E90;
  653.     {$ENDC}
  654.  
  655. TYPE
  656.     FSDRec = RECORD
  657.         fsdLink:                ^FSDRec;                                { ptr to next }
  658.         fsdLength:                INTEGER;                                { length of this FSD in BYTES }
  659.         fsdVersion:                INTEGER;                                { version number }
  660.         fileSystemFSID:            INTEGER;                                { file system id }
  661.         fileSystemName:            Str31;                                    { file system name }
  662.         fileSystemSpec:            FSSpec;                                    { foreign file system's FSSpec }
  663.         fileSystemGlobalsPtr:    Ptr;                                    { ptr to file system globals }
  664.         fileSystemCommProc:        FSDCommUPP;                                { communication proc with the FFS }
  665.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  666.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  667.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  668.         fsdHFSCI:                HFSCIRec;                                { HFS component interface    }
  669.         fsdDICI:                DICIRec;                                { Disk Initialization component interface }
  670.     END;
  671.     FSDRecPtr = ^FSDRec;
  672.  
  673.     FSMGetIconInfoRec = RECORD
  674.         theIcon:                ARRAY [0..31] OF LONGINT;                { The ICN# structure }
  675.         theMask:                ARRAY [0..31] OF LONGINT;                { The mask for the icon above }
  676.         whereStr:                Str255;
  677.     END;
  678.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  679.  
  680. {
  681.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  682.  }
  683.     FSMGetIconRec = RECORD
  684.         refNum:                    INTEGER;                                { target drive num or volume refnum }
  685.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    { pointer to icon buffer }
  686.         requestSize:            LONGINT;                                { requested size of the icon buffer }
  687.         actualSize:                LONGINT;                                { actual size of the icon data returned }
  688.         iconType:                CHAR;                                    { kind of icon }
  689.         isEjectable:            BOOLEAN;                                { true if the device is ejectable }
  690.         driveQElemPtr:            DrvQElPtr;                                { pointer to DQE }
  691.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to foreign file system's FSSpec }
  692.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  693.     END;
  694.     FSMGetIconRecPtr = ^FSMGetIconRec;
  695.  
  696. {
  697.  *    HFS Utility routine prototypes
  698.  }
  699.  
  700. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  701.     {$IFC NOT GENERATINGCFM}
  702.     INLINE $7000, $A824;
  703.     {$ENDC}
  704. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  705.     {$IFC NOT GENERATINGCFM}
  706.     INLINE $7001, $A824;
  707.     {$ENDC}
  708. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  709.     {$IFC NOT GENERATINGCFM}
  710.     INLINE $7002, $A824;
  711.     {$ENDC}
  712. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  713.     {$IFC NOT GENERATINGCFM}
  714.     INLINE $7003, $A824;
  715.     {$ENDC}
  716. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  717.     {$IFC NOT GENERATINGCFM}
  718.     INLINE $7004, $A824;
  719.     {$ENDC}
  720. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  721.     {$IFC NOT GENERATINGCFM}
  722.     INLINE $7005, $A824;
  723.     {$ENDC}
  724. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  725.     {$IFC NOT GENERATINGCFM}
  726.     INLINE $7006, $A824;
  727.     {$ENDC}
  728. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  729.     {$IFC NOT GENERATINGCFM}
  730.     INLINE $7007, $A824;
  731.     {$ENDC}
  732. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  733.     {$IFC NOT GENERATINGCFM}
  734.     INLINE $7008, $A824;
  735.     {$ENDC}
  736. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $7009, $A824;
  739.     {$ENDC}
  740. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $700A, $A824;
  743.     {$ENDC}
  744. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $700B, $A824;
  747.     {$ENDC}
  748. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $700C, $A824;
  751.     {$ENDC}
  752. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $700D, $A824;
  755.     {$ENDC}
  756. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $700E, $A824;
  759.     {$ENDC}
  760. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $700F, $A824;
  763.     {$ENDC}
  764. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $7010, $A824;
  767.     {$ENDC}
  768. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $7011, $A824;
  771.     {$ENDC}
  772. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $7012, $A824;
  775.     {$ENDC}
  776. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  777.     {$IFC NOT GENERATINGCFM}
  778.     INLINE $702B, $A824;
  779.     {$ENDC}
  780. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  781.     {$IFC NOT GENERATINGCFM}
  782.     INLINE $7013, $A824;
  783.     {$ENDC}
  784. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  785.     {$IFC NOT GENERATINGCFM}
  786.     INLINE $7014, $A824;
  787.     {$ENDC}
  788. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  789.     {$IFC NOT GENERATINGCFM}
  790.     INLINE $7015, $A824;
  791.     {$ENDC}
  792. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  793.     {$IFC NOT GENERATINGCFM}
  794.     INLINE $7016, $A824;
  795.     {$ENDC}
  796. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  797.     {$IFC NOT GENERATINGCFM}
  798.     INLINE $7017, $A824;
  799.     {$ENDC}
  800. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  801.     {$IFC NOT GENERATINGCFM}
  802.     INLINE $7018, $A824;
  803.     {$ENDC}
  804. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $7019, $A824;
  807.     {$ENDC}
  808. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  809.     {$IFC NOT GENERATINGCFM}
  810.     INLINE $701A, $A824;
  811.     {$ENDC}
  812. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  813.     {$IFC NOT GENERATINGCFM}
  814.     INLINE $701B, $A824;
  815.     {$ENDC}
  816. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  817.     {$IFC NOT GENERATINGCFM}
  818.     INLINE $701C, $A824;
  819.     {$ENDC}
  820. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  821.     {$IFC NOT GENERATINGCFM}
  822.     INLINE $701D, $A824;
  823.     {$ENDC}
  824. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  825.     {$IFC NOT GENERATINGCFM}
  826.     INLINE $701F, $A824;
  827.     {$ENDC}
  828. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  829.     {$IFC NOT GENERATINGCFM}
  830.     INLINE $7020, $A824;
  831.     {$ENDC}
  832. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  833.     {$IFC NOT GENERATINGCFM}
  834.     INLINE $7021, $A824;
  835.     {$ENDC}
  836. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  837.     {$IFC NOT GENERATINGCFM}
  838.     INLINE $7023, $A824;
  839.     {$ENDC}
  840. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  841.     {$IFC NOT GENERATINGCFM}
  842.     INLINE $7024, $A824;
  843.     {$ENDC}
  844. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  845.     {$IFC NOT GENERATINGCFM}
  846.     INLINE $7025, $A824;
  847.     {$ENDC}
  848. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  849.     {$IFC NOT GENERATINGCFM}
  850.     INLINE $7026, $A824;
  851.     {$ENDC}
  852. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  853.     {$IFC NOT GENERATINGCFM}
  854.     INLINE $7027, $A824;
  855.     {$ENDC}
  856. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  857.     {$IFC NOT GENERATINGCFM}
  858.     INLINE $7028, $A824;
  859.     {$ENDC}
  860. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  861.     {$IFC NOT GENERATINGCFM}
  862.     INLINE $702C, $A824;
  863.     {$ENDC}
  864. {
  865.  *    File System Manager call prototypes
  866.  }
  867. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  868. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  869. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  870. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  871. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  872. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  873.  
  874. {$ALIGN RESET}
  875. {$POP}
  876.  
  877. {$SETC UsingIncludes := FSMIncludes}
  878.  
  879. {$ENDC} {__FSM__}
  880.  
  881. {$IFC NOT UsingIncludes}
  882.  END.
  883. {$ENDC}
  884.